package com.atguigu.tingshu.user.service.impl;

import com.alibaba.fastjson.JSON;
import com.atguigu.tingshu.common.constant.SystemConstant;
import com.atguigu.tingshu.common.rabbit.constant.MqConst;
import com.atguigu.tingshu.common.rabbit.service.RabbitService;
import com.atguigu.tingshu.common.util.MongoUtil;
import com.atguigu.tingshu.model.user.UserListenProcess;
import com.atguigu.tingshu.user.service.UserListenProcessService;
import com.atguigu.tingshu.vo.album.TrackStatMqVo;
import com.atguigu.tingshu.vo.user.UserListenProcessVo;
import io.swagger.v3.core.util.Json;
import org.bson.types.ObjectId;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@Service
@SuppressWarnings({"all"})
public class UserListenProcessServiceImpl implements UserListenProcessService {

	@Autowired
	private MongoTemplate mongoTemplate;

	@Autowired
	private RedisTemplate redisTemplate;

	@Autowired
	private RabbitService rabbitService;


	@Override
	public Map<String, Object> getLatelyTrack(Long userId) {
		// 声明一个map 集合
		Map<String, Object> map = new HashMap<>();
		//获取集合名称
		String collectionName = MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId);
		//设置查询条件
		Query query = new Query();
		// 按照更新时间做降序排列
		query.with(Sort.by(Sort.Direction.DESC, "updateTime")).limit(1);
		// 按照条件查询数据并返回结果
		UserListenProcess userListenProcess = mongoTemplate.findOne(query, UserListenProcess.class,collectionName);
		if(null != userListenProcess) {
			// 存储数据
			map.put("albumId", userListenProcess.getAlbumId());
			map.put("trackId", userListenProcess.getTrackId());
		}
		// 返回数据
		return map;
	}

	@Override
	public void updateListenProcess(Long userId, UserListenProcessVo userListenProcessVo) {

		//查询MongoDB中是否有该用户的声音播放进度信息
		//获取集合名称
		String collectionName = MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId);
		//创建一个MongoDB查询对象，查询条件是 trackId （声音ID）字段等于传入的 trackId 参数值。
		Query query = Query.query(Criteria.where("trackId").is(userListenProcessVo.getTrackId()));
		//查找符合条件的第一个 UserListenProcess 对象
		UserListenProcess userListenProcess = mongoTemplate.findOne(query, UserListenProcess.class, collectionName);
		//判断查询结果是否为空，如果不为空,证明原来有数据，覆盖之前的数据
		if(null  != userListenProcess) {
			userListenProcess.setBreakSecond(userListenProcessVo.getBreakSecond());
			userListenProcess.setUpdateTime(new Date());
		}else {
			//	创建对象
			userListenProcess = new UserListenProcess();
			//	设置用户Id
			userListenProcess.setUserId(userId);
			//	设置专辑Id
			userListenProcess.setAlbumId(userListenProcessVo.getAlbumId());
			//	设置声音Id
			userListenProcess.setTrackId(userListenProcessVo.getTrackId());
			//	设置播放进度
			userListenProcess.setBreakSecond(userListenProcessVo.getBreakSecond());
			//	创建时间
			userListenProcess.setCreateTime(new Date());
			//	更新时间
			userListenProcess.setUpdateTime(new Date());
		}
		//保存数据
		this.mongoTemplate.save(userListenProcess, collectionName);


		//利用分布式锁解决重复播放，防止恶意刷单
		String key = userId+":"+userListenProcessVo.getTrackId();
		// 过期时间 24 小时
		Boolean result = this.redisTemplate.opsForValue().setIfAbsent(key, "1", 24, TimeUnit.HOURS);

		if(result) {
			//	拿到锁，说明是24小时内的第一次播放，专辑和声音的播放量加1
			//创建统计音频播放数据的消息对象
			TrackStatMqVo trackStatMqVo = new TrackStatMqVo();
			//设置统计数量为1，表示增加一次播放量
			trackStatMqVo.setCount(1);
			//统计类型为播放类型
			trackStatMqVo.setStatType(SystemConstant.TRACK_STAT_PLAY);
			//设置音频ID，从用户播放进度对象中获取
			trackStatMqVo.setTrackId(userListenProcessVo.getTrackId());
			//设置专辑ID，从用户播放进度对象中获取
			trackStatMqVo.setAlbumId(userListenProcessVo.getAlbumId());
			String uuid = UUID.randomUUID().toString().replace("-", "");
			trackStatMqVo.setBusinessNo(uuid);
			//通过RabbitMQ发送消息，参数说明：
			//MqConst.EXCHANGE_ALBUM：交换机名称//MqConst.ROUTING_TRACK_STAT_UPDATE：路由键//JSON.toJSONString(trackStatMqVo)：将统计对象序列化为JSON字符串后发送
			rabbitService.sendMessage(MqConst.EXCHANGE_ALBUM,MqConst.ROUTING_TRACK_STAT_UPDATE, JSON.toJSONString(trackStatMqVo));
		}

	}

	@Override
	public BigDecimal getTrackBreakSecond(Long trackId, Long userId) {

		//获取集合名称
		String collectionName = MongoUtil.getCollectionName(MongoUtil.MongoCollectionEnum.USER_LISTEN_PROCESS, userId);
		//创建一个MongoDB查询对象，查询条件是 trackId （声音ID）字段等于传入的 trackId 参数值。
		Query query = Query.query(Criteria.where("trackId").is(trackId));
		//查找符合条件的第一个 UserListenProcess 对象
		UserListenProcess userListenProcess = mongoTemplate.findOne(query, UserListenProcess.class, collectionName);
		//判断查询结果是否为空，如果不为空则返回该用户在该音频中的断点时间（秒数
		if(null  != userListenProcess) {
			return userListenProcess.getBreakSecond();
		}
		//如果没有找到对应的记录，则返回默认值0.00秒，表示从头开始播放。
		return new BigDecimal("0.00");
	}
}
